

var Node = function Node(){
};catvm.safefunction(Node);
Object.defineProperties(Node.prototype,{
    [Symbol.toStringTag]:{
        value:"Node",
        configurable:true
    }
});
Node.prototype.__proto__ = EventTarget.prototype;

var Document = function Document(){
};catvm.safefunction(Document);
Object.defineProperties(Document.prototype,{
    [Symbol.toStringTag]:{
        value:"Document",
        configurable:true
    }
});

////
// Document.prototype = {
//     get URL() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = location.href;
//         return result;
//     },
//     get activeElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     adoptNode() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get adoptedStyleSheets() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set adoptedStyleSheets(value) {
//     },
//     get alinkColor() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set alinkColor(value) {
//     },
//     get all() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get anchors() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     append() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get applets() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get bgColor() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set bgColor(value) {
//     },
//     get body() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set body(value) {
//     },
//     captureEvents() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     caretRangeFromPoint() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get characterSet() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = 'UTF-8';
//         return result;
//     },
//     get charset() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = 'UTF-8';
//         return result;
//     },
//     get childElementCount() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get children() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     clear() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     close() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get compatMode() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = 'CSS1Compat';
//         return result;
//     },
//     get contentType() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get cookie() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set cookie(value) {
//         if (value === null) {
//             return ;
//         }
//         if (typeof value === "symbol") {
//             throw new TypeError("Cannot convert a Symbol value to a string")
//         }
    
//         const S = String(value);
//         const n = S.length;
//         const U = [];
//         for (let i = 0; i < n; ++i) {
//             const c = S.charCodeAt(i);
//             if (c < 0xD800 || c > 0xDFFF) {
//                 U.push(String.fromCodePoint(c));
//             } else if (0xDC00 <= c && c <= 0xDFFF) {
//                 U.push(String.fromCodePoint(0xFFFD));
//             } else if (i === n - 1) {
//                 U.push(String.fromCodePoint(0xFFFD));
//             } else {
//                 const d = S.charCodeAt(i + 1);
//                 if (0xDC00 <= d && d <= 0xDFFF) {
//                     const a = c & 0x3FF;
//                     const b = d & 0x3FF;
//                     U.push(String.fromCodePoint((2 << 15) + ((2 << 9) * a) + b));
//                     ++i;
//                 } else {
//                     U.push(String.fromCodePoint(0xFFFD));
//                 }
//             }
//         }
//     },
//     createAttribute() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createAttributeNS() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createCDATASection() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createComment() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createDocumentFragment() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createElement(tagName, options) {
//         let tagname = tagName.toLowerCase() + "";
//         console.log(tagname, '---')
//         let ele;
//         let result = ele;
//         return result;
//     },
//     createElementNS() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createEvent(type) {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let ele;
//         switch(type.toLowerCase()){
//             case 'event':
//                 ele = new Event(lwVm.memory.$createObj_key);
//                 break;
//             case 'events':
//                 ele = new Event(lwVm.memory.$createObj_key);
//                 break;
//             case 'uievent':
//                 ele = new UIEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'uievents':
//                 ele = new UIEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'mouseevent':
//                 ele = new MouseEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'mouseevents':
//                 ele = new MouseEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'mutationevent':
//                 ele = new MutationEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'mutationevents':
//                 ele = new MutationEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'textevent':
//                 ele = new TextEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'textevents':
//                 ele = new TextEvent(lwVm.memory.$createObj_key);
//                 break;
//             case 'keyboardevent':
//                 ele = new KeyboardEvent(lwVm.memory.$createObj_key);
//                 break;
            
//             case 'customevent':
//                 ele = new CustomEvent(lwVm.memory.$createObj_key);
//                 break;
                
//             default:
//                 throw new DOMException(`Failed to execute 'createEvent' on 'Document': The provided event type ('${type}') is invalid.`)
//         }
//         ele.isTrusted =  false;
//         return ele;

//     },
//     createExpression() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createNSResolver() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createNodeIterator() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createProcessingInstruction() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createRange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createTextNode() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     createTreeWalker() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get currentScript() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = null;
//         return result;
//     },
//     get defaultView() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get designMode() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set designMode(value) {
//     },
//     get dir() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set dir(value) {
//     },
//     get doctype() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get documentElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };

//     },
//     get documentURI() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get domain() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set domain(value) {
//     },
//     elementFromPoint() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     elementsFromPoint() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get embeds() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     evaluate() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     execCommand() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     exitFullscreen() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     exitPictureInPicture() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     exitPointerLock() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get featurePolicy() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get fgColor() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set fgColor(value) {
//     },
//     get firstElementChild() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get fonts() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get forms() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get fragmentDirective() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get fullscreen() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set fullscreen(value) {
//     },
//     get fullscreenElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set fullscreenElement(value) {
//     },
//     get fullscreenEnabled() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set fullscreenEnabled(value) {
//     },
//     getAnimations() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     getElementById(id) {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     getElementsByClassName() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     getElementsByName() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     getElementsByTagName(tagName) {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         if (tagName === "*") {
//             return lwVm.memory.htmlCollection;
//         };
        
//         tagName = tagName.toLowerCase();
        
//         let collection = new HTMLCollection(lwVm.memory.$createObj_key);
//         let collection_index = 0;

//         for (let i = 0; i < lwVm.memory.htmlCollection.length; i++) {
//             let node_onj = lwVm.memory.htmlCollection[i];
//             console.log(node_onj.localName, node_onj.localName, tagName)
//             if (node_onj.localName && node_onj.localName === tagName) {
//                 collection[collection_index] = node_onj;
//                 collection_index++;
//             }
//         }
//         let result = collection;
//         return result;
//     },
//     getElementsByTagNameNS() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     getSelection() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     hasFocus() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get head() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };

//     },
//     get hidden() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = true;
//         return result;
//     },
//     get images() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get implementation() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     importNode() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get inputEncoding() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get lastElementChild() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get lastModified() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get linkColor() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set linkColor(value) {
//     },
//     get links() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get onabort() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onabort(value) {
//     },
//     get onanimationend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onanimationend(value) {
//     },
//     get onanimationiteration() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onanimationiteration(value) {
//     },
//     get onanimationstart() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onanimationstart(value) {
//     },
//     get onauxclick() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onauxclick(value) {
//     },
//     get onbeforecopy() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onbeforecopy(value) {
//     },
//     get onbeforecut() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         return result;
//     },
//     set onbeforecut(value) {
//     },
//     get onbeforepaste() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onbeforepaste(value) {
//     },
//     get onbeforexrselect() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onbeforexrselect(value) {
//     },
//     get onblur() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onblur(value) {
//     },
//     get oncancel() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         return result;
//     },
//     set oncancel(value) {
//     },
//     get oncanplay() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oncanplay(value) {
//     },
//     get oncanplaythrough() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oncanplaythrough(value) {
//     },
//     get onchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onchange(value) {
//     },
//     get onclick() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onclick(value) {
//     },
//     get onclose() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onclose(value) {
//     },
//     get oncontextmenu() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oncontextmenu(value) {
//     },
//     get oncopy() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oncopy(value) {
//     },
//     get oncuechange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oncuechange(value) {
//     },
//     get oncut() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oncut(value) {
//     },
//     get ondblclick() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondblclick(value) {
//     },
//     get ondrag() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondrag(value) {
//     },
//     get ondragend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondragend(value) {
//     },
//     get ondragenter() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondragenter(value) {
//     },
//     get ondragleave() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondragleave(value) {
//     },
//     get ondragover() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondragover(value) {
//     },
//     get ondragstart() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondragstart(value) {
//     },
//     get ondrop() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondrop(value) {
//     },
//     get ondurationchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ondurationchange(value) {
//     },
//     get onemptied() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onemptied(value) {
//     },
//     get onended() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onended(value) {
//     },
//     get onerror() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onerror(value) {
//     },
//     get onfocus() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onfocus(value) {
//     },
//     get onformdata() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onformdata(value) {
//     },
//     get onfreeze() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onfreeze(value) {
//     },
//     get onfullscreenchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onfullscreenchange(value) {
//     },
//     get onfullscreenerror() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onfullscreenerror(value) {
//     },
//     get ongotpointercapture() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ongotpointercapture(value) {
//     },
//     get oninput() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oninput(value) {
//     },
//     get oninvalid() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set oninvalid(value) {
//     },
//     get onkeydown() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onkeydown(value) {
//     },
//     get onkeypress() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onkeypress(value) {
//     },
//     get onkeyup() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onkeyup(value) {
//     },
//     get onload() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onload(value) {
//     },
//     get onloadeddata() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onloadeddata(value) {
//     },
//     get onloadedmetadata() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onloadedmetadata(value) {
//     },
//     get onloadstart() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onloadstart(value) {
//     },
//     get onlostpointercapture() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onlostpointercapture(value) {
//     },
//     get onmousedown() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onmousedown(value) {
//     },
//     onmouseenter: undefined,
//     onmouseleave: undefined,
//     get onmousemove() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onmousemove(value) {
//     },
//     get onmouseout() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onmouseout(value) {
//     },
//     get onmouseover() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onmouseover(value) {
//     },
//     get onmouseup() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onmouseup(value) {
//     },
//     get onmousewheel() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onmousewheel(value) {
//     },
//     get onpaste() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpaste(value) {
//     },
//     get onpause() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpause(value) {
//     },
//     get onplay() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onplay(value) {
//     },
//     get onplaying() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onplaying(value) {
//     },
//     get onpointercancel() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointercancel(value) {
//     },
//     get onpointerdown() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerdown(value) {
//     },
//     get onpointerenter() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerenter(value) {
//     },
//     get onpointerleave() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerleave(value) {
//     },
//     get onpointerlockchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerlockchange(value) {
//     },
//     get onpointerlockerror() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerlockerror(value) {
//     },
//     get onpointermove() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointermove(value) {
//     },
//     get onpointerout() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerout(value) {
//     },
//     get onpointerover() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerover(value) {
//     },
//     get onpointerrawupdate() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerrawupdate(value) {
//     },
//     get onpointerup() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onpointerup(value) {
//     },
//     get onprogress() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onprogress(value) {
//     },
//     get onratechange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onratechange(value) {
//     },
//     onreadystatechange: undefined,
//     get onreset() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onreset(value) {
//     },
//     get onresize() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onresize(value) {
//     },
//     get onresume() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onresume(value) {
//     },
//     get onscroll() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onscroll(value) {
//     },
//     get onsearch() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onsearch(value) {
//     },
//     get onsecuritypolicyviolation() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onsecuritypolicyviolation(value) {
//     },
//     get onseeked() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onseeked(value) {
//     },
//     get onseeking() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onseeking(value) {
//     },
//     get onselect() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onselect(value) {
//     },
//     get onselectionchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onselectionchange(value) {
//     },
//     get onselectstart() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onselectstart(value) {
//     },
//     get onslotchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onslotchange(value) {
//     },
//     get onstalled() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onstalled(value) {
//     },
//     get onsubmit() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onsubmit(value) {
//     },
//     get onsuspend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onsuspend(value) {
//     },
//     get ontimeupdate() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ontimeupdate(value) {
//     },
//     get ontoggle() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ontoggle(value) {
//     },
//     get ontransitioncancel() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ontransitioncancel(value) {
//     },
//     get ontransitionend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ontransitionend(value) {
//     },
//     get ontransitionrun() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ontransitionrun(value) {
//     },
//     get ontransitionstart() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set ontransitionstart(value) {
//     },
//     get onvisibilitychange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onvisibilitychange(value) {
//     },
//     get onvolumechange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onvolumechange(value) {
//     },
//     get onwaiting() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwaiting(value) {
//     },
//     get onwebkitanimationend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwebkitanimationend(value) {
//     },
//     get onwebkitanimationiteration() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwebkitanimationiteration(value) {
//     },
//     get onwebkitanimationstart() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwebkitanimationstart(value) {
//     },
//     get onwebkitfullscreenchange() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwebkitfullscreenchange(value) {
//     },
//     get onwebkitfullscreenerror() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwebkitfullscreenerror(value) {
//     },
//     get onwebkittransitionend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwebkittransitionend(value) {
//     },
//     get onwheel() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set onwheel(value) {
//     },
//     open() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get pictureInPictureElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get pictureInPictureEnabled() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get plugins() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get pointerLockElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     prepend() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     queryCommandEnabled() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     queryCommandIndeterm() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     queryCommandState() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     queryCommandSupported() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     queryCommandValue() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     querySelector() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     querySelectorAll() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get readyState() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = "complete";
//         return result;
//     },
//     get referrer() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     releaseEvents() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     replaceChildren() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get rootElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get scripts() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get scrollingElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get styleSheets() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get timeline() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get title() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set title(value) {
//     },
//     get visibilityState() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = "hidden";
//         return result;
//     },
//     get vlinkColor() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set vlinkColor(value) {
//     },
//     get wasDiscarded() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = false;
//         return result;
//     },
//     webkitCancelFullScreen() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get webkitCurrentFullScreenElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     webkitExitFullscreen() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get webkitFullscreenElement() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get webkitFullscreenEnabled() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get webkitHidden() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//         let result = true;
//     },
//     get webkitIsFullScreen() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get webkitVisibilityState() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     write() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     writeln() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get xmlEncoding() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     get xmlStandalone() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set xmlStandalone(value) {
//     },
//     get xmlVersion() {
//         if (!Document.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
//     },
//     set xmlVersion(value) {
//     },
// }


/////
Document.prototype.__proto__ = Node.prototype;


///
const $safe_get_attribute = [
    'URL', 'activeElement', 'adoptedStyleSheets', 'alinkColor', 'all', 'anchors', 'applets', 'bgColor', 'body', 'characterSet',
    'charset', 'childElementCount', 'children', 'compatMode', 'contentType', 'cookie', 'currentScript', 'defaultView', 'designMode', 'dir', 'doctype',
    'documentElement', 'documentURI', 'domain', 'embeds', 'featurePolicy', 'fgColor', 'firstElementChild', 'fonts', 'forms', 'fragmentDirective', 'fullscreen',
    'fullscreenElement', 'fullscreenEnabled', 'head', 'hidden', 'images', 'implementation', 'inputEncoding', 'lastElementChild', 'lastModified', 'linkColor',
    'links', 'onabort', 'onanimationend', 'onanimationiteration', 'onanimationstart', 'onauxclick', 'onbeforecopy', 'onbeforecut', 'onbeforepaste',
    'onbeforexrselect', 'onblur', 'oncancel', 'oncanplay', 'oncanplaythrough', 'onchange', 'onclick', 'onclose', 'oncontextmenu', 'oncopy', 'oncuechange',
    'oncut', 'ondblclick', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'ondurationchange', 'onemptied',
    'onended', 'onerror', 'onfocus', 'onformdata', 'onfreeze', 'onfullscreenchange', 'onfullscreenerror', 'ongotpointercapture', 'oninput', 'oninvalid',
    'onkeydown', 'onkeypress', 'onkeyup', 'onload', 'onloadeddata', 'onloadedmetadata', 'onloadstart', 'onlostpointercapture', 'onmousedown', 'onmousemove',
    'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onpaste', 'onpause', 'onplay', 'onplaying', 'onpointercancel', 'onpointerdown',
    'onpointerenter', 'onpointerleave', 'onpointerlockchange', 'onpointerlockerror', 'onpointermove', 'onpointerout', 'onpointerover', 'onpointerrawupdate',
    'onpointerup', 'onprogress', 'onratechange', 'onreset', 'onresize', 'onresume', 'onscroll', 'onsearch', 'onsecuritypolicyviolation', 'onseeked',
    'onseeking', 'onselect', 'onselectionchange', 'onselectstart', 'onslotchange', 'onstalled', 'onsubmit', 'onsuspend', 'ontimeupdate', 'ontoggle',
    'ontransitioncancel', 'ontransitionend', 'ontransitionrun', 'ontransitionstart', 'onvisibilitychange', 'onvolumechange', 'onwaiting', 'onwebkitanimationend',
    'onwebkitanimationiteration', 'onwebkitanimationstart', 'onwebkitfullscreenchange', 'onwebkitfullscreenerror', 'onwebkittransitionend', 'onwheel',
    'pictureInPictureElement', 'pictureInPictureEnabled', 'plugins', 'pointerLockElement', 'readyState', 'referrer', 'rootElement', 'scripts',
    'scrollingElement', 'styleSheets', 'timeline', 'title', 'visibilityState', 'vlinkColor', 'wasDiscarded', 'webkitCurrentFullScreenElement',
    'webkitFullscreenElement', 'webkitFullscreenEnabled', 'webkitHidden', 'webkitIsFullScreen', 'webkitVisibilityState', 'xmlEncoding', 'xmlStandalone',
    'xmlVersion'
];
const $safe_set_attribute = [
    'adoptedStyleSheets', 'alinkColor', 'bgColor', 'body', 'cookie', 'designMode', 'dir', 'domain', 'fgColor', 'fullscreen', 'fullscreenElement',
    'fullscreenEnabled', 'linkColor', 'onabort', 'onanimationend', 'onanimationiteration', 'onanimationstart', 'onauxclick', 'onbeforecopy',
    'onbeforecut', 'onbeforepaste', 'onbeforexrselect', 'onblur', 'oncancel', 'oncanplay', 'oncanplaythrough', 'onchange', 'onclick', 'onclose',
    'oncontextmenu', 'oncopy', 'oncuechange', 'oncut', 'ondblclick', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart',
    'ondrop', 'ondurationchange', 'onemptied', 'onended', 'onerror', 'onfocus', 'onformdata', 'onfreeze', 'onfullscreenchange', 'onfullscreenerror',
    'ongotpointercapture', 'oninput', 'oninvalid', 'onkeydown', 'onkeypress', 'onkeyup', 'onload', 'onloadeddata', 'onloadedmetadata', 'onloadstart',
    'onlostpointercapture', 'onmousedown', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onpaste', 'onpause', 'onplay',
    'onplaying', 'onpointercancel', 'onpointerdown', 'onpointerenter', 'onpointerleave', 'onpointerlockchange', 'onpointerlockerror', 'onpointermove',
    'onpointerout', 'onpointerover', 'onpointerrawupdate', 'onpointerup', 'onprogress', 'onratechange', 'onreset', 'onresize', 'onresume', 'onscroll',
    'onsearch', 'onsecuritypolicyviolation', 'onseeked', 'onseeking', 'onselect', 'onselectionchange', 'onselectstart', 'onslotchange', 'onstalled',
    'onsubmit', 'onsuspend', 'ontimeupdate', 'ontoggle', 'ontransitioncancel', 'ontransitionend', 'ontransitionrun', 'ontransitionstart',
    'onvisibilitychange', 'onvolumechange', 'onwaiting', 'onwebkitanimationend', 'onwebkitanimationiteration', 'onwebkitanimationstart',
    'onwebkitfullscreenchange', 'onwebkitfullscreenerror', 'onwebkittransitionend', 'onwheel', 'title', 'vlinkColor', 'xmlStandalone', 'xmlVersion'
];
const $safe_func_attribute = [
    'adoptNode', 'append', 'captureEvents', 'caretRangeFromPoint', 'clear', 'close', 'createAttribute', 'createAttributeNS', 'createCDATASection',
    'createComment', 'createDocumentFragment', 'createElement', 'createElementNS', 'createEvent', 'createExpression', 'createNSResolver',
    'createNodeIterator', 'createProcessingInstruction', 'createRange', 'createTextNode', 'createTreeWalker', 'elementFromPoint', 'elementsFromPoint',
    'evaluate', 'execCommand', 'exitFullscreen', 'exitPictureInPicture', 'exitPointerLock', 'getAnimations', 'getElementById', 'getElementsByClassName',
    'getElementsByName', 'getElementsByTagName', 'getElementsByTagNameNS', 'getSelection', 'hasFocus', 'importNode', 'open', 'prepend', 'queryCommandEnabled',
    'queryCommandIndeterm', 'queryCommandState', 'queryCommandSupported', 'queryCommandValue', 'querySelector', 'querySelectorAll', 'releaseEvents',
    'replaceChildren', 'webkitCancelFullScreen', 'webkitExitFullscreen', 'write', 'writeln'
];
// catvm.safe_Objattribute(Document, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);



//


var HTMLDocument = function HTMLDocument(){
};catvm.safefunction(HTMLDocument);
Object.defineProperties(HTMLDocument.prototype,{
    [Symbol.toStringTag]:{
        value:"HTMLDocument",
        configurable:true
    }
});
HTMLDocument.prototype.__proto__ = Document.prototype;
document = {
};
document.__proto__ = HTMLDocument.prototype;
document.cookie = "";
document.referrer = location?.href || "";
////////////
document.getElementById = function getElementById(id){
    debugger;
    return null
};catvm.safefunction(document.getElementById);

document.addEventListener = function addEventListener(type,listener,options,useCapture){
    // debugger;
};
catvm.safefunction(document.addEventListener);
document.body = catvm.proxy(catvm.memory.htmlelements['body']());
document.createElement = function createElement(tagName){
    var tagname = tagName.toLowerCase()+"";
    if(catvm.memory.htmlelements[tagname]!=undefined){
    //    debugger;
       return catvm.proxy(catvm.memory.htmlelements[tagname]());
    }
    return {
        style : {
            "accentColor": "",
            "additiveSymbols": "",
        },
        tagName : tagname,
        offsetHeight : 0,
        firstChild : {},
        appendChild : function appendChild(){self.offsetHeight=20; return div},
        remove : div_remove,
    };;
};catvm.safefunction(document.createElement);

document.documentElement = {
    getAttribute:function getAttribute(){return null}

};catvm.safefunction(document.documentElement.getAttribute);
////////////
document = catvm.proxy(document);